/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Utils;

import java.util.InputMismatchException;

/**
 *
 * @author Douglas
 */
public class ValidaCNPJCPF 
{
    public static boolean isCNPJ(String CNPJ) 
    {
        CNPJ = CNPJ.replaceAll(".","");  
        CNPJ = CNPJ.replaceAll("-","");
        CNPJ = CNPJ.replaceAll("/","");
        CNPJ = CNPJ.replaceAll(" ",""); 
        // considera-se erro CNPJ's formados por uma sequencia de numeros iguais
        if (CNPJ.equals("00000000000000") || CNPJ.equals("11111111111111") ||
            CNPJ.equals("22222222222222") || CNPJ.equals("33333333333333") ||
            CNPJ.equals("44444444444444") || CNPJ.equals("55555555555555") ||
            CNPJ.equals("66666666666666") || CNPJ.equals("77777777777777") ||
            CNPJ.equals("88888888888888") || CNPJ.equals("99999999999999") ||
           (CNPJ.length() != 14))
           return(false);

        char dig13, dig14;
        int sm, i, r, num, peso;

        // "try" - protege o código para eventuais erros de conversao de tipo (int)
        try 
        {
        // Calculo do 1o. Digito Verificador
            sm = 0;
            peso = 2;
            for (i=11; i>=0; i--) 
            {
            // converte o i-ésimo caractere do CNPJ em um número:
            // por exemplo, transforma o caractere '0' no inteiro 0
            // (48 eh a posição de '0' na tabela ASCII)
                num = (int)(CNPJ.charAt(i) - 48);
                sm = sm + (num * peso);
                peso = peso + 1;
                if (peso == 10)
                peso = 2;
            }

            r = sm % 11;
            if ((r == 0) || (r == 1))
                dig13 = '0';
            else 
                dig13 = (char)((11-r) + 48);

            // Calculo do 2o. Digito Verificador
            sm = 0;
            peso = 2;
            for (i=12; i>=0; i--) 
            {
                num = (int)(CNPJ.charAt(i)- 48);
                sm = sm + (num * peso);
                peso = peso + 1;
                if (peso == 10)
                    peso = 2;
            }

            r = sm % 11;
            if ((r == 0) || (r == 1))
                dig14 = '0';
            else 
                dig14 = (char)((11-r) + 48);

            // Verifica se os dígitos calculados conferem com os dígitos informados.
            if ((dig13 == CNPJ.charAt(12)) && (dig14 == CNPJ.charAt(13)))
                return(true);
            else 
                return(false);
        } 
        catch (InputMismatchException erro) 
        {
            return(false);
        }
      }
 
      public static String imprimeCNPJ(String CNPJ) 
      {
        // máscara do CNPJ: 99.999.999.9999-99
        return(CNPJ.substring(0, 2) + "." + CNPJ.substring(2, 5) + "." +
          CNPJ.substring(5, 8) + "." + CNPJ.substring(8, 12) + "-" +
          CNPJ.substring(12, 14));
      }
  
      public  boolean validacpf(String strCpf)
      { // formato XXX.XXX.XXX-XX  
          if (! strCpf.substring(0,1).equals(""))
          {  
            try
            {  
                boolean validado=true;  
                int     d1, d2;  
                int     digito1, digito2, resto;  
                int     digitoCPF;  
                String  nDigResult;  
                strCpf = strCpf.replace('.',' ');  
                strCpf = strCpf.replace('-',' ');  
                strCpf = strCpf.replaceAll(" ","");  
                d1 = d2 = 0;  
                digito1 = digito2 = resto = 0;  

                for (int nCount = 1; nCount < strCpf.length() -1; nCount++) {  
                    digitoCPF = Integer.valueOf(strCpf.substring(nCount -1, nCount)).intValue();  

                    //multiplique a ultima casa por 2 a seguinte por 3 a seguinte por 4 e assim por diante.  
                    d1 = d1 + ( 11 - nCount ) * digitoCPF;  

                    //para o segundo digito repita o procedimento incluindo o primeiro digito calculado no passo anterior.  
                    d2 = d2 + ( 12 - nCount ) * digitoCPF;  
                };  

                //Primeiro resto da divisão por 11.  
                resto = (d1 % 11);  

                //Se o resultado for 0 ou 1 o digito é 0 caso contrário o digito é 11 menos o resultado anterior.  
                if (resto < 2)  
                    digito1 = 0;  
                else  
                    digito1 = 11 - resto;  

                d2 += 2 * digito1;  

                //Segundo resto da divisão por 11.  
                resto = (d2 % 11);  

                //Se o resultado for 0 ou 1 o digito é 0 caso contrário o digito é 11 menos o resultado anterior.  
                if (resto < 2)  
                    digito2 = 0;  
                else  
                    digito2 = 11 - resto;  

                //Digito verificador do CPF que está sendo validado.  
                String nDigVerific = strCpf.substring(strCpf.length()-2, strCpf.length());  

                //Concatenando o primeiro resto com o segundo.  
                nDigResult = String.valueOf(digito1) + String.valueOf(digito2);  

                //comparar o digito verificador do cpf com o primeiro resto + o segundo resto.  
                return nDigVerific.equals(nDigResult);  
            }
            catch (Exception e)
            {  
                System.err.println("Erro !"+e);  
                return false;  
            }  
        }
        else 
            return false;  
      }      
}
